home *** CD-ROM | disk | FTP | other *** search
/ Aminet 50 / Aminet 50 (2002)(GTI - Schatztruhe)[!][Aug 2002].iso / Aminet / util / libs / mpega_libmad.lha / mpega_libmad / wrap_mpega.c < prev    next >
C/C++ Source or Header  |  2002-06-23  |  26KB  |  1,006 lines
  1. #include "wrap_mpega.h"
  2. #include "compiler.h"
  3.  
  4. #include <proto/dos.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7.  
  8. #include "audio.h"
  9. #include "stream.h"
  10. #include "frame.h"
  11. #include "synth.h"
  12. #include "resample.h"
  13. #include "equalizer.h"
  14. #include "timer.h"
  15. #include "xing.h"
  16.  
  17. #ifdef BUILD_WARPUP
  18. #include <powerpc/powerpc.h>
  19. #include <proto/powerpc.h>
  20. #elif defined(BUILD_POWERUP)
  21. #include <powerup/gcclib/powerup_protos.h>
  22.  
  23. #undef Open
  24. #define Open PPCOpen
  25. #undef Close
  26. #define Close PPCClose
  27. #undef Read
  28. #define Read PPCRead
  29. #undef Seek
  30. #define Seek PPCSeek
  31. #endif
  32.  
  33. #define DEFAULT_BUFFER_SIZE 8192
  34.  
  35. typedef struct
  36. {
  37.     BPTR fh;
  38.     UBYTE *buffer;
  39.     ULONG streamsize;
  40.     ULONG streamskip;
  41.  
  42.     MPEGA_CTRL *ctrl;
  43.     MPEGA_ACCESS *access;
  44.  
  45.     struct mad_stream stream;
  46.     struct mad_frame frame;
  47.     struct mad_synth synth;
  48.  
  49.     struct xing xing;
  50.     mad_timer_t timer;
  51.  
  52.     struct audio_dither left_dither;
  53.     struct audio_dither right_dither;
  54.  
  55.     mad_fixed_t attenuate;
  56.     struct equalizer equalizer;
  57.  
  58.     struct resample_state resample[2];
  59.     mad_fixed_t resampled[2][1152];
  60. } DecHandle;
  61.  
  62.  
  63. #ifdef __PPC__
  64. #ifdef BUILD_POWERUP
  65. #include <powerup/ppclib/interface.h>
  66. #define CALLHOOK(hook, object, message) \
  67. ({ ULONG ret; \
  68.     struct Caos MyCaos; \
  69.     MyCaos.M68kCacheMode = IF_CACHEFLUSHALL; \
  70.     MyCaos.PPCCacheMode = IF_CACHEFLUSHALL; \
  71.     MyCaos.a0 = (ULONG) hook; \
  72.     MyCaos.a2 = (ULONG) object; \
  73.     MyCaos.a1 = (ULONG) message; \
  74.     MyCaos.caos_Un.Function = hook->h_Entry; \
  75.     ret = PPCCallM68k(&MyCaos); \
  76.     ret; \
  77. })
  78. #elif defined(BUILD_WARPUP)
  79. #define CALLHOOK(hook, object, message) \
  80. ({ ULONG ret; \
  81.     struct PPCArgs args; \
  82.     args.PP_Regs[PPREG_A0] = (ULONG)hook; \
  83.     args.PP_Regs[PPREG_A2] = (ULONG)object; \
  84.     args.PP_Regs[PPREG_A1] = (ULONG)message; \
  85.     args.PP_Code = (APTR)hook->h_Entry; \
  86.     args.PP_Offset = 0; \
  87.     args.PP_Flags = 0; \
  88.     args.PP_Stack = NULL; \
  89.     args.PP_StackSize = 0; \
  90.     Run68K(&args); \
  91.     ret = args.PP_Regs[PPREG_D0]; \
  92.     ret; \
  93. })
  94. #else
  95. #include <emul/emulregs.h>
  96. #include <emul/emulinterface.h>
  97. #define CALLHOOK(hook, object, message) \
  98. ({ ULONG ret; \
  99.     REG_A0 = (ULONG) hook; \
  100.     REG_A2 = (ULONG) object; \
  101.     REG_A1 = (ULONG) message; \
  102.     ret = (*MyEmulHandle->EmulCallDirect68k)(hook->h_Entry); \
  103.     ret; \
  104. })
  105. #endif
  106. #else
  107. #if 0
  108. static ULONG ASM MyCallHook(REG(a0, struct Hook *hook), REG(a2, APTR object), REG(a1, APTR message))
  109. {
  110.     return hook->h_Entry();
  111. }
  112. #define CALLHOOK MyCallHook
  113. #else
  114. #define CALLHOOK(hook, object, message) \
  115. ({ register ULONG ret __asm("d0"); \
  116.     register struct Hook *_hook __asm("a0") = hook; \
  117.     register APTR _object __asm("a2") = object; \
  118.     register APTR _message __asm("a1") = message; \
  119.     __asm volatile ("movel a0@(8:W),a3\n\t" "jsr a3@" : "=r" (ret) : "r" (_hook), "r" (_object), "r" (_message) : "d0", "a0", "a1", "a2", "a3", "cc", "memory"); \
  120.     ret; \
  121. })
  122. #endif
  123. #endif
  124.  
  125.  
  126. static __inline void SetStreamValues(MPEGA_STREAM *mpega_stream, struct mad_header *header)
  127. {
  128.     switch (header->mode)
  129.     {
  130.         case MAD_MODE_SINGLE_CHANNEL:
  131.             mpega_stream->mode = MPEGA_MODE_MONO;
  132.             break;
  133.  
  134.         case MAD_MODE_DUAL_CHANNEL:
  135.             mpega_stream->mode = MPEGA_MODE_DUAL;
  136.             break;
  137.  
  138.         case MAD_MODE_JOINT_STEREO:
  139.             mpega_stream->mode = MPEGA_MODE_J_STEREO;
  140.             break;
  141.  
  142.         case MAD_MODE_STEREO:
  143.             mpega_stream->mode = MPEGA_MODE_STEREO;
  144.             break;
  145.  
  146.         default:
  147.             mpega_stream->mode = -1;
  148.             break;
  149.     }
  150.  
  151.     mpega_stream->norm = ((header->flags & MAD_FLAG_LSF_EXT) ? 2 : 1);
  152.     mpega_stream->layer = header->layer;
  153.     mpega_stream->bitrate = header->bitrate / 1000;
  154.     mpega_stream->frequency = header->samplerate;
  155.     mpega_stream->channels = ((header->mode == MAD_MODE_SINGLE_CHANNEL) ? 1 : 2);
  156.  
  157.     mpega_stream->private_bit = ((header->private_bits & MAD_PRIVATE_HEADER) ? 1 : 0);
  158.     mpega_stream->copyright = ((header->flags & MAD_FLAG_COPYRIGHT) ? 1 : 0);
  159.     mpega_stream->original = ((header->flags & MAD_FLAG_ORIGINAL) ? 1 : 0);
  160. }
  161.  
  162. static __inline void ClearStreamValues(MPEGA_STREAM *mpega_stream)
  163. {
  164.     /* Dummy values */
  165.     mpega_stream->mode = MPEGA_MODE_J_STEREO;
  166.     mpega_stream->norm = 1;
  167.     mpega_stream->layer = 3;
  168.     mpega_stream->bitrate = 128;
  169.     mpega_stream->frequency = 44100;
  170.     mpega_stream->channels = 2;
  171.  
  172.     mpega_stream->private_bit = 0;
  173.     mpega_stream->copyright = 0;
  174.     mpega_stream->original = 0;
  175.  
  176.     mpega_stream->ms_duration = 1000;
  177.  
  178.     mpega_stream->dec_channels = 2;
  179.     mpega_stream->dec_quality = 2;
  180.     mpega_stream->dec_frequency = 44100;
  181. }
  182.  
  183. static __inline void SetStreamOptions(MPEGA_STREAM *mpega_stream, MPEGA_CTRL *ctrl, DecHandle *dechandle)
  184. {
  185.     MPEGA_LAYER *layer = ((mpega_stream->layer == 3) ? (&ctrl->layer_3) : (&ctrl->layer_1_2));
  186.     MPEGA_OUTPUT *output;
  187.     LONG freq;
  188.  
  189.     if (layer->force_mono || mpega_stream->channels == 1)
  190.     {
  191.         output = &layer->mono;
  192.         mpega_stream->dec_channels = 1;
  193.     } else {
  194.         output = &layer->stereo;
  195.         mpega_stream->dec_channels = 2;
  196.     }
  197.  
  198.     if (output->quality == 0)
  199.     {
  200.         switch (output->freq_div)
  201.         {
  202.             case 4:
  203.                 if ((freq = mpega_stream->frequency / 4) > 8000)
  204.                 {
  205.                     mad_stream_options(&dechandle->stream, MAD_OPTION_QUARTSAMPLERATE);
  206.                     mpega_stream->dec_frequency = freq;
  207.                     break;
  208.                 }
  209.                 /* Fall through */
  210.  
  211.             case 2:
  212.                 if ((freq = mpega_stream->frequency / 2) > 8000)
  213.                 {
  214.                     mad_stream_options(&dechandle->stream, MAD_OPTION_HALFSAMPLERATE);
  215.                     mpega_stream->dec_frequency = freq;
  216.                     break;
  217.                 }
  218.                 /* Fall through */
  219.  
  220.             case 0:
  221.                 if ((freq = mpega_stream->frequency) > output->freq_max)
  222.                 {
  223.                     LONG freqdiv = freq / output->freq_max;
  224.  
  225.                     switch (freqdiv)
  226.                     {
  227.                         case 6:
  228.                         case 5:
  229.                         case 4:
  230.                             freq /= 4;
  231.                             mad_stream_options(&dechandle->stream, MAD_OPTION_QUARTSAMPLERATE);
  232.  
  233.                             resample_init(&dechandle->resample[0], freq, output->freq_max);
  234.                             if (mpega_stream->dec_channels == 2)
  235.                                 resample_init(&dechandle->resample[1], freq, output->freq_max);
  236.  
  237.                             mpega_stream->dec_frequency = output->freq_max;
  238.                             break;
  239.  
  240.                         case 3:
  241.                         case 2:
  242.                             freq /= 2;
  243.                             mad_stream_options(&dechandle->stream, MAD_OPTION_HALFSAMPLERATE);
  244.  
  245.                             resample_init(&dechandle->resample[0], freq, output->freq_max);
  246.                             if (mpega_stream->dec_channels == 2)
  247.                                 resample_init(&dechandle->resample[1], freq, output->freq_max);
  248.  
  249.                             mpega_stream->dec_frequency = output->freq_max;
  250.                             break;
  251.  
  252.                         default:
  253.                             mad_stream_options(&dechandle->stream, 0);
  254.  
  255.                             resample_init(&dechandle->resample[0], mpega_stream->frequency, freq);
  256.                             if (mpega_stream->dec_channels == 2)
  257.                                 resample_init(&dechandle->resample[1], mpega_stream->frequency, freq);
  258.  
  259.                             mpega_stream->dec_frequency = freq;
  260.                             break;
  261.                     }
  262.  
  263.                     break;
  264.                 }
  265.                 /* Fall through */
  266.  
  267.             default:
  268.                 mad_stream_options(&dechandle->stream, 0);
  269.                 mpega_stream->dec_frequency = mpega_stream->frequency;
  270.                 break;
  271.         }
  272.     } else {
  273.         switch (output->freq_div)
  274.         {
  275.             case 4:
  276.                 if ((freq = mpega_stream->frequency / 4) > 8000)
  277.                 {
  278.                     resample_init(&dechandle->resample[0], mpega_stream->frequency, freq);
  279.                     if (mpega_stream->dec_channels == 2)
  280.                         resample_init(&dechandle->resample[1], mpega_stream->frequency, freq);
  281.  
  282.                     mpega_stream->dec_frequency = freq;
  283.                     break;
  284.                 }
  285.                 /* Fall through */
  286.  
  287.             case 2:
  288.                 if ((freq = mpega_stream->frequency / 2) > 8000)
  289.                 {
  290.                     resample_init(&dechandle->resample[0], mpega_stream->frequency, freq);
  291.                     if (mpega_stream->dec_channels == 2)
  292.                         resample_init(&dechandle->resample[1], mpega_stream->frequency, freq);
  293.  
  294.                     mpega_stream->dec_frequency = freq;
  295.                     break;
  296.                 }
  297.                 /* Fall through */
  298.  
  299.             case 0:
  300.                 if ((freq = mpega_stream->frequency) > output->freq_max)
  301.                 {
  302.                     resample_init(&dechandle->resample[0], freq, output->freq_max);
  303.                     if (mpega_stream->dec_channels == 2)
  304.                         resample_init(&dechandle->resample[1], freq, output->freq_max);
  305.  
  306.                     mpega_stream->dec_frequency = output->freq_max;
  307.                     break;
  308.                 }
  309.                 /* Fall through */
  310.  
  311.             default:
  312.                 mpega_stream->dec_frequency = mpega_stream->frequency;
  313.                 break;
  314.         }
  315.     }
  316.  
  317.     if ((mpega_stream->dec_quality = output->quality) < 2) dechandle->stream.options |= MAD_OPTION_IGNORECRC;
  318. }
  319.  
  320. static __inline ULONG CheckID3(UBYTE *buffer)
  321. {
  322.     ULONG size = 0;
  323.  
  324.     if (buffer[0]=='I' && buffer[1]=='D' && buffer[2]=='3' && buffer[3]<0xFF && buffer[4]<0xFF && buffer[6]<0x80 && buffer[7]<0x80 && buffer[8]<0x80 && buffer[9]<0x80)
  325.     {
  326.         size = 10 + (((buffer[6] & 0x7F) << 21) | ((buffer[7] & 0x7F) << 14) | ((buffer[8] & 0x7F) << 7) | buffer[9] & 0x7F);
  327.  
  328.         if (buffer[5] & 0x10)
  329.             size += 10;
  330.     }
  331.  
  332.     return size;
  333. }
  334.  
  335. static __inline LONG ReadFunc(DecHandle *dechandle, UBYTE *buffer, LONG len)
  336. {
  337.     MPEGA_CTRL *ctrl = dechandle->ctrl;
  338.     LONG bytes;
  339.  
  340.     if (ctrl->bs_access == NULL)
  341.     {
  342.         bytes = Read(dechandle->fh, buffer, len);
  343.     } else {
  344.         MPEGA_ACCESS *access = dechandle->access;
  345.  
  346.         access->func = MPEGA_BSFUNC_READ;
  347.         access->data.read.buffer = buffer;
  348.         access->data.read.num_bytes = len;
  349.  
  350.         bytes = CALLHOOK(ctrl->bs_access, (APTR)dechandle->fh, access);
  351.     }
  352.  
  353.     return bytes;
  354. }
  355.  
  356. static LONG InitDecoder(MPEGA_STREAM *mpega_stream, MPEGA_CTRL *ctrl)
  357. {
  358.     DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
  359.     LONG bytes;
  360.  
  361.     mad_stream_init(&dechandle->stream);
  362.     mad_frame_init(&dechandle->frame);
  363.     mad_synth_init(&dechandle->synth);
  364.  
  365.     xing_init(&dechandle->xing);
  366.     resample_init(&dechandle->resample[0], 44100, 44100);
  367.     resample_init(&dechandle->resample[1], 44100, 44100);
  368.     mad_timer_reset(&dechandle->timer);
  369.     dechandle->attenuate = MAD_F_ONE;
  370.  
  371.     bytes = ReadFunc(dechandle, dechandle->buffer, ctrl->stream_buffer_size);
  372.  
  373.     if (bytes > 0)
  374.     {
  375.         ULONG skip;
  376.  
  377.         ClearStreamValues(mpega_stream);
  378.         dechandle->streamskip = skip = CheckID3(dechandle->buffer);
  379.         if (dechandle->streamsize == 0) dechandle->streamsize = ((bytes > skip) ? (bytes) : (skip));
  380.  
  381.         /* Ensure that we have something to decode */
  382.         if (skip > (bytes - 2000))
  383.         {
  384.             LONG len = 0, size = bytes;
  385.  
  386.             if (skip < size)
  387.             {
  388.                 bytes = len = size - skip;
  389.                 memmove(dechandle->buffer, dechandle->buffer + (size - len), len);
  390.                 skip = size;
  391.             }
  392.  
  393.             while (skip >= size)
  394.             {
  395.                 skip -= size;
  396.                 size = ReadFunc(dechandle, dechandle->buffer + len, ctrl->stream_buffer_size - len);
  397.  
  398.                 if (size <= 0) return 0;
  399.             }
  400.  
  401.             if (skip)
  402.             {
  403.                 bytes = len = size - skip;
  404.                 memmove(dechandle->buffer, dechandle->buffer + (size - len), len);
  405.                 size = ReadFunc(dechandle, dechandle->buffer + len, ctrl->stream_buffer_size - len);
  406.             }
  407.  
  408.             if (size > 0) bytes += size;
  409.         }
  410.  
  411.         bzero(dechandle->buffer + bytes, MAD_BUFFER_GUARD);
  412.         mad_stream_buffer(&dechandle->stream, dechandle->buffer, bytes);
  413.  
  414.         dechandle->stream.sync = 0;
  415.         mad_stream_options(&dechandle->stream, MAD_OPTION_IGNORECRC);
  416.  
  417.         if (mad_frame_decode(&dechandle->frame, &dechandle->stream) == -1)
  418.         {
  419.             while (MAD_RECOVERABLE(dechandle->stream.error))
  420.             {
  421.                 dechandle->stream.error = 0;
  422.                 if (mad_frame_decode(&dechandle->frame, &dechandle->stream) == 0) break;
  423.             }
  424.  
  425.             if (dechandle->stream.error)
  426.             {
  427.                 mad_stream_options(&dechandle->stream, 0);
  428.                 if (ctrl->check_mpeg && dechandle->streamsize > bytes) return 0;
  429.  
  430.                 return 1;
  431.             }
  432.         }
  433.  
  434.         mad_stream_options(&dechandle->stream, 0);
  435.         SetStreamValues(mpega_stream, &dechandle->frame.header);
  436.  
  437.         if (xing_parse(&dechandle->xing, dechandle->stream.anc_ptr, dechandle->stream.anc_bitlen) == 0)
  438.         {
  439.             skip = dechandle->stream.next_frame - dechandle->buffer;
  440.             dechandle->streamskip += skip;
  441.  
  442.             if (dechandle->xing.flags & XING_FRAMES)
  443.             {
  444.                 ULONG seconds;
  445.                 mad_timer_t total = dechandle->frame.header.duration;
  446.  
  447.                 mad_timer_multiply(&total, dechandle->xing.frames);
  448.                 mpega_stream->ms_duration = mad_timer_count(total, MAD_UNITS_MILLISECONDS);
  449.                 seconds = ((mpega_stream->ms_duration > 1000) ? (mpega_stream->ms_duration / 1000) : (1));
  450.  
  451.                 if (dechandle->xing.flags & XING_BYTES)
  452.                 {
  453.                     mpega_stream->bitrate = ((dechandle->xing.bytes / 125) / seconds);
  454.                 } else {
  455.                     mpega_stream->bitrate = (((dechandle->streamsize - dechandle->streamskip) / 125) / seconds);
  456.                 }
  457.             }
  458.         } else {
  459.             skip = dechandle->stream.this_frame - dechandle->buffer;
  460.             dechandle->streamskip += skip;
  461.  
  462.             if (dechandle->streamsize)
  463.             {
  464. #if 0
  465.                 mad_timer_t total = dechandle->frame.header.duration;
  466.  
  467.                 mad_timer_multiply(&total, ((dechandle->streamsize - dechandle->streamskip) / (dechandle->stream.next_frame - dechandle->stream.this_frame)));
  468.                 mpega_stream->ms_duration = mad_timer_count(total, MAD_UNITS_MILLISECONDS);
  469. #else
  470.                 /* This will overflow on files over 500MB, but is more accurate than the above */
  471.                 mpega_stream->ms_duration = ((dechandle->streamsize - dechandle->streamskip) * 8) / ((mpega_stream->bitrate) ? (mpega_stream->bitrate) : (8));
  472. #endif
  473.             }
  474.  
  475.             mad_stream_buffer(&dechandle->stream, dechandle->buffer + skip, bytes - skip);
  476.             mad_frame_mute(&dechandle->frame);
  477.         }
  478.  
  479.         SetStreamOptions(mpega_stream, ctrl, dechandle);
  480.  
  481.         return 1;
  482.     }
  483.  
  484.     return 0;
  485. }
  486.  
  487. static void FinishDecoder(DecHandle *dechandle)
  488. {
  489.     resample_finish(&dechandle->resample[0]);
  490.     resample_finish(&dechandle->resample[1]);
  491.     xing_finish(&dechandle->xing);
  492.     mad_synth_finish(&dechandle->synth);
  493.     mad_frame_finish(&dechandle->frame);
  494.     mad_stream_finish(&dechandle->stream);
  495. }
  496.  
  497. static __inline LONG ValidateFrequency(LONG freq)
  498. {
  499.     if (freq <= 0) return 48000;
  500.     if (freq <= 8000) return 8000;
  501.     if (freq <= 11025) return 11025;
  502.     if (freq <= 12000) return 12000;
  503.     if (freq <= 16000) return 16000;
  504.     if (freq <= 22050) return 22050;
  505.     if (freq <= 24000) return 24000;
  506.     if (freq <= 32000) return 32000;
  507.     if (freq <= 44100) return 44100;
  508.  
  509.     return 48000;
  510. }
  511.  
  512. static __inline void ValidateCtrl(MPEGA_CTRL *ctrl)
  513. {
  514.     if (ctrl->stream_buffer_size < DEFAULT_BUFFER_SIZE)
  515.         ctrl->stream_buffer_size = DEFAULT_BUFFER_SIZE;
  516.  
  517.     if (ctrl->layer_1_2.mono.freq_div < 0)
  518.         ctrl->layer_1_2.mono.freq_div = 0;
  519.  
  520.     if (ctrl->layer_1_2.mono.freq_div > 2)
  521.         ctrl->layer_1_2.mono.freq_div = 4;
  522.  
  523.     if (ctrl->layer_1_2.mono.quality < 0)
  524.         ctrl->layer_1_2.mono.quality = 0;
  525.  
  526.     if (ctrl->layer_1_2.mono.quality > 2)
  527.         ctrl->layer_1_2.mono.quality = 2;
  528.  
  529.     if (ctrl->layer_1_2.stereo.freq_div < 0)
  530.         ctrl->layer_1_2.stereo.freq_div = 0;
  531.  
  532.     if (ctrl->layer_1_2.stereo.freq_div > 2)
  533.         ctrl->layer_1_2.stereo.freq_div = 4;
  534.  
  535.     if (ctrl->layer_1_2.stereo.quality < 0)
  536.         ctrl->layer_1_2.stereo.quality = 0;
  537.  
  538.     if (ctrl->layer_1_2.stereo.quality > 2)
  539.         ctrl->layer_1_2.stereo.quality = 2;
  540.  
  541.     ctrl->layer_1_2.mono.freq_max = ValidateFrequency(ctrl->layer_1_2.mono.freq_max);
  542.     ctrl->layer_1_2.stereo.freq_max = ValidateFrequency(ctrl->layer_1_2.stereo.freq_max);
  543.  
  544.     if (ctrl->layer_3.mono.freq_div < 0)
  545.         ctrl->layer_3.mono.freq_div = 0;
  546.  
  547.     if (ctrl->layer_3.mono.freq_div > 2)
  548.         ctrl->layer_3.mono.freq_div = 4;
  549.  
  550.     if (ctrl->layer_3.mono.quality < 0)
  551.         ctrl->layer_3.mono.quality = 0;
  552.  
  553.     if (ctrl->layer_3.mono.quality > 2)
  554.         ctrl->layer_3.mono.quality = 2;
  555.  
  556.     if (ctrl->layer_3.stereo.freq_div < 0)
  557.         ctrl->layer_3.stereo.freq_div = 0;
  558.  
  559.     if (ctrl->layer_3.stereo.freq_div > 2)
  560.         ctrl->layer_3.stereo.freq_div = 4;
  561.  
  562.     if (ctrl->layer_3.stereo.quality < 0)
  563.         ctrl->layer_3.stereo.quality = 0;
  564.  
  565.     if (ctrl->layer_3.stereo.quality > 2)
  566.         ctrl->layer_3.stereo.quality = 2;
  567.  
  568.     ctrl->layer_3.mono.freq_max = ValidateFrequency(ctrl->layer_3.mono.freq_max);
  569.     ctrl->layer_3.stereo.freq_max = ValidateFrequency(ctrl->layer_3.stereo.freq_max);
  570. }
  571.  
  572. static __inline LONG OutputPCM(MPEGA_STREAM *mpega_stream, DecHandle *dechandle, WORD *pcm[MPEGA_MAX_CHANNELS])
  573. {
  574.     WORD *outleft = pcm[0];
  575.     WORD *outright = pcm[1];
  576.     mad_fixed_t const *left = dechandle->synth.pcm.samples[0];
  577.     mad_fixed_t const *right = dechandle->synth.pcm.samples[1];
  578.     ULONG len = dechandle->synth.pcm.length;
  579.     LONG nsamples, sample0, sample1;
  580.  
  581.     nsamples = len;
  582.  
  583.     if (mpega_stream->dec_channels == 1 || !outright)
  584.     {
  585.         if (dechandle->resample[0].ratio != MAD_F_ONE)
  586.         {
  587.             nsamples = resample_block(&dechandle->resample[0], len, left, dechandle->resampled[0]);
  588.             left = dechandle->resampled[0];
  589.         }
  590.  
  591.         if (mpega_stream->dec_quality < 2)
  592.         {
  593.             while (len--)
  594.             {
  595.                 sample0 = audio_linear_round(16, *left++);
  596.  
  597.                 *outleft++ = sample0 & 0x0000FFFF;
  598.             }
  599.         } else {
  600.             while (len--)
  601.             {
  602.                 sample0 = audio_linear_dither(16, *left++, &dechandle->left_dither);
  603.  
  604.                 *outleft++ = sample0 & 0x0000FFFF;
  605.             }
  606.         }
  607.     } else {    /* Stereo */
  608.         if (dechandle->resample[0].ratio != MAD_F_ONE)
  609.         {
  610.             nsamples = resample_block(&dechandle->resample[0], len, left, dechandle->resampled[0]);
  611.             resample_block(&dechandle->resample[1], len, right, dechandle->resampled[1]);
  612.             left = dechandle->resampled[0];
  613.             right = dechandle->resampled[1];
  614.         }
  615.  
  616.         if (mpega_stream->dec_quality < 2)
  617.         {
  618.             while (len--)
  619.             {
  620.                 sample0 = audio_linear_round(16, *left++);
  621.                 sample1 = audio_linear_round(16, *right++);
  622.  
  623.                 *outleft++ = sample0 & 0x0000FFFF;
  624.                 *outright++ = sample1 & 0x0000FFFF;
  625.             }
  626.         } else {
  627.             while (len--)
  628.             {
  629.                 sample0 = audio_linear_dither(16, *left++, &dechandle->left_dither);
  630.                 sample1 = audio_linear_dither(16, *right++, &dechandle->right_dither);
  631.  
  632.                 *outleft++ = sample0 & 0x0000FFFF;
  633.                 *outright++ = sample1 & 0x0000FFFF;
  634.             }
  635.         }
  636.     }
  637.  
  638.     return nsamples;
  639. }
  640.  
  641.  
  642. MPEGA_STREAM * LIBPPC WRAP_MPEGA_open(char *stream_name, MPEGA_CTRL *ctrl)
  643. {
  644.     if (ctrl)
  645.     {
  646.         MPEGA_STREAM *mpega_stream;
  647.  
  648.         if ((mpega_stream = malloc(sizeof(MPEGA_STREAM))))
  649.         {
  650.             DecHandle *dechandle;
  651.  
  652.             if ((dechandle = calloc(1, sizeof(DecHandle))))
  653.             {
  654.                 mpega_stream->handle = dechandle;
  655.  
  656.                 dechandle->fh = NULL;
  657.                 dechandle->access = NULL;
  658.  
  659.                 ValidateCtrl(ctrl);
  660.  
  661.                 if ((dechandle->ctrl = malloc(sizeof(MPEGA_CTRL))))
  662.                 {
  663.                     bcopy(ctrl, dechandle->ctrl, sizeof(MPEGA_CTRL));
  664.  
  665.                     if ((dechandle->buffer = malloc(ctrl->stream_buffer_size + MAD_BUFFER_GUARD)))
  666.                     {
  667.                         if (ctrl->bs_access == NULL)
  668.                         {
  669.                             if (stream_name)
  670.                             {
  671.                                 if ((dechandle->fh = Open(stream_name, MODE_OLDFILE)))
  672.                                 {
  673.                                     struct FileInfoBlock *fib;
  674.  
  675.                                     dechandle->streamsize = 0;
  676.  
  677.                                     if ((fib = malloc(sizeof(struct FileInfoBlock))))
  678.                                     {
  679.                                         if (ExamineFH(dechandle->fh, fib))
  680.                                         {
  681.                                             dechandle->streamsize = fib->fib_Size;
  682.                                         }
  683.  
  684.                                         free(fib);
  685.                                     }
  686.  
  687.                                     if (InitDecoder(mpega_stream, ctrl) != 0)
  688.                                     {
  689.                                         return mpega_stream;
  690.                                     }
  691.  
  692.                                     Close(dechandle->fh);
  693.                                 }
  694.                             }
  695.                         } else {
  696.                             MPEGA_ACCESS *access;
  697.  
  698.                             if ((access = malloc(sizeof(MPEGA_ACCESS))))
  699.                             {
  700.                                 dechandle->access = access;
  701.  
  702.                                 access->func = MPEGA_BSFUNC_OPEN;
  703.                                 access->data.open.stream_name = stream_name;
  704.                                 access->data.open.buffer_size = ctrl->stream_buffer_size;
  705.                                 access->data.open.stream_size = 0;
  706.  
  707.                                 if ((dechandle->fh = CALLHOOK(ctrl->bs_access, NULL, access)))
  708.                                 {
  709.                                     dechandle->streamsize = access->data.open.stream_size;
  710.  
  711.                                     if (InitDecoder(mpega_stream, ctrl) != 0)
  712.                                     {
  713.                                         return mpega_stream;
  714.                                     }
  715.  
  716.                                     access->func = MPEGA_BSFUNC_CLOSE;
  717.                                     CALLHOOK(ctrl->bs_access, (APTR)dechandle->fh, access);
  718.                                 }
  719.  
  720.                                 free(access);
  721.                             }
  722.                         }
  723.  
  724.                         free(dechandle->buffer);
  725.                     }
  726.  
  727.                     free(dechandle->ctrl);
  728.                 }
  729.  
  730.                 free(dechandle);
  731.             }
  732.  
  733.             free(mpega_stream);
  734.         }
  735.     }
  736.  
  737.     return NULL;
  738. }
  739.  
  740. void LIBPPC WRAP_MPEGA_close(MPEGA_STREAM *mpega_stream)
  741. {
  742.     if (mpega_stream)
  743.     {
  744.         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
  745.  
  746.         if (dechandle)
  747.         {
  748.             MPEGA_CTRL *ctrl = dechandle->ctrl;
  749.  
  750.             FinishDecoder(dechandle);
  751.  
  752.             if (ctrl->bs_access == NULL)
  753.             {
  754.                 if (dechandle->fh) Close(dechandle->fh);
  755.             } else {
  756.                 MPEGA_ACCESS *access = dechandle->access;
  757.  
  758.                 access->func = MPEGA_BSFUNC_CLOSE;
  759.  
  760.                 CALLHOOK(ctrl->bs_access, (APTR)dechandle->fh, access);
  761.             }
  762.  
  763.             if (dechandle->ctrl) free(dechandle->ctrl);
  764.             if (dechandle->buffer) free(dechandle->buffer);
  765.             if (dechandle->access) free(dechandle->access);
  766.  
  767.             free(dechandle);
  768.         }
  769.  
  770.         free(mpega_stream);
  771.     }
  772. }
  773.  
  774. LONG LIBPPC WRAP_MPEGA_decode_frame(MPEGA_STREAM *mpega_stream, WORD *pcm[MPEGA_MAX_CHANNELS])
  775. {
  776.     if (mpega_stream && pcm && pcm[0])
  777.     {
  778.         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
  779.         MPEGA_CTRL *ctrl = dechandle->ctrl;
  780.  
  781.         if (mad_frame_decode(&dechandle->frame, &dechandle->stream) == -1)
  782.         {
  783.             LONG error = dechandle->stream.error;
  784.  
  785.             if (error == MAD_ERROR_BUFLEN)
  786.             {
  787.                 LONG bytes = ctrl->stream_buffer_size, len = 0;
  788.  
  789.                 if (dechandle->stream.next_frame)
  790.                 {
  791.                     memmove(dechandle->buffer, dechandle->stream.next_frame, len = &dechandle->buffer[bytes] - dechandle->stream.next_frame);
  792.                 }
  793.  
  794.                 bytes = ReadFunc(dechandle, dechandle->buffer + len, bytes - len);
  795.  
  796.                 if (bytes == 0) return MPEGA_ERR_EOF;
  797.                 if (bytes < 0) return MPEGA_ERR_BADVALUE;
  798.  
  799.                 bzero(dechandle->buffer + bytes + len, MAD_BUFFER_GUARD);
  800.                 mad_stream_buffer(&dechandle->stream, dechandle->buffer, bytes + len);
  801.  
  802.                 if (mad_frame_decode(&dechandle->frame, &dechandle->stream) == -1) error = dechandle->stream.error;
  803.                 else error = 0;
  804.             }
  805.  
  806.             if (error)
  807.             {
  808.                 switch (error)
  809.                 {
  810.                     case MAD_ERROR_BUFPTR:
  811.                         return MPEGA_ERR_BADVALUE;
  812.                         break;
  813.  
  814.                     case MAD_ERROR_NOMEM:
  815.                         return MPEGA_ERR_MEM;
  816.                         break;
  817.  
  818.                     case MAD_ERROR_LOSTSYNC:
  819.                         return MPEGA_ERR_NO_SYNC;
  820.                         break;
  821.  
  822.                     case MAD_ERROR_BADLAYER:
  823.                     case MAD_ERROR_BADBITRATE:
  824.                     case MAD_ERROR_BADSAMPLERATE:
  825.                     case MAD_ERROR_BADEMPHASIS:
  826.                     case MAD_ERROR_BADCRC:
  827.                     case MAD_ERROR_BADBITALLOC:
  828.                     case MAD_ERROR_BADSCALEFACTOR:
  829.                     case MAD_ERROR_BADFRAMELEN:
  830.                     case MAD_ERROR_BADBIGVALUES:
  831.                     case MAD_ERROR_BADBLOCKTYPE:
  832.                     case MAD_ERROR_BADSCFSI:
  833.                     case MAD_ERROR_BADDATAPTR:
  834.                     case MAD_ERROR_BADPART3LEN:
  835.                     case MAD_ERROR_BADHUFFTABLE:
  836.                     case MAD_ERROR_BADHUFFDATA:
  837.                     case MAD_ERROR_BADSTEREO:
  838.                         return MPEGA_ERR_BADFRAME;
  839.                         break;
  840.  
  841.                     default:
  842.                         return -error;
  843.                         break;
  844.                 }
  845.             }
  846.         }
  847.  
  848.         mad_timer_add(&dechandle->timer, dechandle->frame.header.duration);
  849.  
  850.         SetStreamValues(mpega_stream, &dechandle->frame.header);
  851.         SetStreamOptions(mpega_stream, ctrl, dechandle);
  852.  
  853.         if (dechandle->attenuate != MAD_F_ONE)
  854.             equalizer_filter(&dechandle->equalizer, &dechandle->frame);
  855.  
  856.         mad_synth_frame(&dechandle->synth, &dechandle->frame);
  857.  
  858.         return OutputPCM(mpega_stream, dechandle, pcm);
  859.     }
  860.  
  861.     return MPEGA_ERR_BADVALUE;
  862. }
  863.  
  864. LONG LIBPPC WRAP_MPEGA_seek(MPEGA_STREAM *mpega_stream, ULONG ms_time_position)
  865. {
  866.     if (mpega_stream)
  867.     {
  868.         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
  869.         MPEGA_CTRL *ctrl = dechandle->ctrl;
  870.         LONG pos, error;
  871.  
  872.         if (dechandle->xing.flags & XING_TOC)
  873.         {
  874.             int step, i = 99;
  875.  
  876.             if (dechandle->xing.flags & XING_BYTES)
  877.             {
  878.                 step = dechandle->xing.bytes / 256;
  879.             } else {
  880.                 step = (dechandle->streamsize - dechandle->streamskip) / 256;
  881.             }
  882.  
  883.             if (ms_time_position < mpega_stream->ms_duration)
  884.             {
  885.                 i = ((mpega_stream->ms_duration > 100) ? (ms_time_position / (mpega_stream->ms_duration / 100)) : (0));
  886.                 if (i > 99) i = 99;
  887.             }
  888.  
  889.             pos = (step * dechandle->xing.toc[i]) + dechandle->streamskip;
  890.         } else {
  891.             pos = ((((ULONG)mpega_stream->bitrate * 125UL) * (ms_time_position / 1000)) + dechandle->streamskip);
  892.         }
  893.  
  894.         if (ctrl->bs_access == NULL)
  895.         {
  896.             error = Seek(dechandle->fh, pos, OFFSET_BEGINNING);
  897.  
  898.             if (error > 0) error = 0;
  899.         } else {
  900.             MPEGA_ACCESS *access = dechandle->access;
  901.  
  902.             access->func = MPEGA_BSFUNC_SEEK;
  903.             access->data.seek.abs_byte_seek_pos = pos;
  904.  
  905.             error = CALLHOOK(ctrl->bs_access, (APTR)dechandle->fh, access);
  906.         }
  907.  
  908.         if (error == 0)
  909.         {
  910.             LONG bytes;
  911.  
  912.             bytes = ReadFunc(dechandle, dechandle->buffer, ctrl->stream_buffer_size);
  913.  
  914.             if (bytes == 0) return MPEGA_ERR_EOF;
  915.             if (bytes < 0) return MPEGA_ERR_BADVALUE;
  916.  
  917.             bzero(dechandle->buffer + bytes, MAD_BUFFER_GUARD);
  918.             mad_stream_buffer(&dechandle->stream, dechandle->buffer, bytes);
  919.  
  920.             mad_frame_mute(&dechandle->frame);
  921.             mad_synth_mute(&dechandle->synth);
  922.             dechandle->stream.sync = 0;
  923.  
  924.             /* If we seek somewhere other than the beginning we need to flush out junk audio */
  925.             if (pos > dechandle->streamskip)
  926.             {
  927.                 mad_frame_decode(&dechandle->frame, &dechandle->stream);
  928.                 mad_frame_decode(&dechandle->frame, &dechandle->stream);
  929.                 mad_synth_frame(&dechandle->synth, &dechandle->frame);
  930.             }
  931.  
  932. //            mad_timer_set(&dechandle->timer, 0, pos - dechandle->streamskip, (ULONG)mpega_stream->bitrate * 125);
  933.             mad_timer_set(&dechandle->timer, 0, ms_time_position, 1000);
  934.  
  935.             return 0;
  936.         }
  937.     }
  938.  
  939.     return MPEGA_ERR_BADVALUE;
  940. }
  941.  
  942. LONG LIBPPC WRAP_MPEGA_time(MPEGA_STREAM *mpega_stream, ULONG *ms_time_position)
  943. {
  944.     if (mpega_stream && ms_time_position)
  945.     {
  946.         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
  947.  
  948.         *ms_time_position = mad_timer_count(dechandle->timer, MAD_UNITS_MILLISECONDS);
  949.         return 0;
  950.     }
  951.  
  952.     return MPEGA_ERR_BADVALUE;
  953. }
  954.  
  955. LONG LIBPPC WRAP_MPEGA_find_sync(UBYTE *buffer, LONG buffer_size)
  956. {
  957.     if (buffer && buffer_size > 75)
  958.     {
  959.         LONG i = 0;
  960.  
  961.         while (i < buffer_size - 1)
  962.         {
  963.             if ((buffer[i] == 0xFF) && ((buffer[i+1] & 0xE0) == 0xE0)) return i;
  964.             ++i;
  965.         }
  966.  
  967.         return MPEGA_ERR_NO_SYNC;
  968.     }
  969.  
  970.     return MPEGA_ERR_BADVALUE;
  971. }
  972.  
  973. LONG LIBPPC WRAP_MPEGA_scale(MPEGA_STREAM *mpega_stream, LONG scale_percent)
  974. {
  975.     if (mpega_stream)
  976.     {
  977.         DecHandle *dechandle = (DecHandle *) mpega_stream->handle;
  978.         mad_fixed_t attenuate;
  979.  
  980.         if (scale_percent >= 800) attenuate = MAD_F_MAX;
  981.         else if (scale_percent <= 0) attenuate = ((mad_fixed_t)0x00000001L);
  982.         else attenuate = (MAD_F_ONE / 100) * scale_percent;
  983.  
  984.         equalizer_init(&dechandle->equalizer, attenuate);
  985.         dechandle->attenuate = attenuate;
  986.  
  987.         return 0;
  988.     }
  989.  
  990.     return MPEGA_ERR_BADVALUE;
  991. }
  992.  
  993. #ifdef BUILD_POWERUP
  994. APTR __LibFuncTable[] =
  995. {
  996.     WRAP_MPEGA_open,
  997.     WRAP_MPEGA_close,
  998.     WRAP_MPEGA_decode_frame,
  999.     WRAP_MPEGA_seek,
  1000.     WRAP_MPEGA_time,
  1001.     WRAP_MPEGA_find_sync,
  1002.     WRAP_MPEGA_scale,
  1003.     NULL
  1004. };
  1005. #endif
  1006.